#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Filename: grupo_de_resolucion.py

##
# Módulos del sistema
from datetime import datetime

##
# Módulos propios
try:
    from database import Ticket,Intervencion, HistorialDeClasificacion
    from database import HistorialDeEstado, Estado, Observacion, Clasificacion
except ImportError, error:
    print error
    print "Importando clases de BD. 'grupo_de_resolucion.py'"

class GrupoDeResolucion:
    def __init__(self, grupo):
        """Constructor por defecto.

        Guardo en una variable de instancia 'grupo', para asi despues en las
        susecivas incerciones que tengan asociados este grupo, como por ejemplo
        hacer un 'set' de ticket, ya tengo el dato y no vuelvo a consultar.

        Keyword arguments
        grupo -- type:<class 'lib.database.GrupoDeResolucion'>

        """
        self.grupo = grupo

    def crearClasificacion(self, nombre, descripcion, grupos_asociados):
        nueva = Clasificacion(nombre=nombre,
                descripcion=descripcion,
                historial_de_clasificacion=None)
        for grupo in grupos_asociados:
            nueva.addGrupoDeResolucion(grupo)

    def buscarClasificaciones(self, tipo):
        if tipo==1:
            consulta = Clasificacion.select()
            print consulta
            print "----"
            return consulta
    def modificarClasificacion(self, nombre, estado, descripcion,
            grupos_asociados, clasificacion):
        """Setea en la BD los cambios"""
        print "Llegue"
        if estado == "Desactiva":
            estado = False
        else:
            estado = True
        """
        Cuak! falta ver como romper el Relatedjoin
        clasificacion.set(nombre=nombre, estado=estado,
                descripcion=descripcion)
        clasificacion.
        """

class MesaDeAyuda(GrupoDeResolucion):
    def __init__(self, grupo):
        """Constructor por defecto.

        Keyword arguments
        grupo -- type:<class 'lib.database.GrupoDeResolucion'>
        """
        GrupoDeResolucion.__init__(self, grupo)
        # por ahi estaria bueno levantar los ultimos 10 ticket y almacenarlos
        # acá para mostrarlo en la vista inicial
        self.tickets = {}

    def crearTicket(self, usuario, empleado, clasificacion, descripcion,
            fecha_creacion):
        """Registra en la BD y agrega a la lista el nuevo ticket.

        Crea una instancia de ticket para agregarla a la self.ticket y hace un
        set en la BD en la tabla Ticket.

        Keyword arguments:
        usuario -- usuario que registro esel ticket
        empleado -- empleado solicitante del ticket
        clasificacion -- clasificacion del problema actual
        descripcion -- descripcion del problema
        fecha_creacion -- <type 'datetime.datetime'>

        Return:
        La posicion en la cual se agrego el ticket
        """
        # Nuevo ticket: ver fecha de cierre
        nuevo_ticket = Ticket(fecha_cierre = None,
                numero_ticket = 0,
                fecha_creacion = fecha_creacion,
                descripcion = descripcion,
                grupo_de_resolucion = usuario.grupo_de_resolucion.id,
                empleado = empleado.id,
                usuario_creacion = usuario.id,
                usuario_cierre = None)
        # Primera intervencion: sin observaciones por el momento
        intervencion = Intervencion(fecha = fecha_creacion,
                clasificacion = clasificacion.id,
                grupo_de_resolucion = usuario.grupo_de_resolucion.id,
                ticket = nuevo_ticket.id)
        # Historial de clasificacion
        historial_de_clasificacion = HistorialDeClasificacion(
                fecha = fecha_creacion,
                clasificacion = clasificacion.id,
                ticket = nuevo_ticket.id)
        # Estado: consulto la BD y asigno al estado este historial
        estado = Estado.selectBy(nombre='Abierto en Mesa de Ayuda')[0]

        # Historial de estado
        historial_de_estado = HistorialDeEstado(fecha = fecha_creacion,
                usuario = usuario.id,
                estado = estado.id,
                ticket = nuevo_ticket.id)
        
        self.tickets[nuevo_ticket.id] = nuevo_ticket
       # print self.tickets
        return nuevo_ticket
        
    def cerrarTicket(self, usuario_logueado, observacion, fecha_cierre, ticket):
        """Realiza el cierre del ticket de la posicion 'pos'.

        Keyword arguments:
        usuario_logueado -- usuario que realiza el cierre
        observacion -- observacion de la intervencion
        fecha_cierre -- <type 'datetime.datetime'>

        """
        estado = Estado.selectBy(nombre='Cerrado')[0]
        historial_de_estado=HistorialDeEstado(fecha=fecha_cierre,
                usuario=usuario_logueado.id,
                estado=estado.id,
                ticket=self.tickets[ticket.id].id)
        self.tickets[ticket.id].set(cerrado=True)
        obs = Observacion(descripcion=observacion,
                grupo_de_resolucion=self.tickets[ticket.id].grupo_de_resolucion.id,
                intervencion=self.tickets[ticket.id].intervenciones[-1].id,
                usuario=usuario_logueado.id,
                fecha=fecha_cierre)
        del self.tickets[ticket.id]
        
    
    def derivarTicket(self, grupo, fecha_derivacion, obs, usuario, ticket,
            clasificacion = None):
        """Realiza la derivacion del ticket.

        Keyword arguments:
        """
        if clasificacion:
            historial_de_clasificacion = HistorialDeClasificacion(
                    fecha = fecha_derivacion,
                    clasificacion = clasificacion.id,
                    ticket = self.tickets[ticket.id].id)
        estado = Estado.selectBy(nombre='Abierto derivado')[0]
        self.tickets[ticket.id].set(grupo_de_resolucion = grupo.id)
        # Actualizamos la BD
        historial_de_estado = HistorialDeEstado(fecha = fecha_derivacion,
                usuario = usuario.id,
                estado = estado.id,
                ticket = self.tickets[ticket.id].id)
        #Agregamos una obs a la intervencion
        observacion = Observacion(descripcion = obs,
                grupo_de_resolucion = grupo.id,
                intervencion = self.tickets[ticket.id].intervenciones[-1].id,
                usuario = usuario.id,
                fecha = fecha_derivacion)
        del self.tickets[ticket.id]
        
    def buscarTicket(self,
            empleado,
            ultimo_grupo,
            clasificacion,
            estado,
            nro_ticket,
            fecha_apertura_desde,
            fecha_apertura_hasta,
            fecha_ultimo_cambio_desde,
            fecha_ultimo_cambio_hasta):
        """Busca los tickets que cumplen con lo criterios de busqueda.

        Recorrera la lista de tiket que tenemos en memoria y irá creando la
        'lista_ticket', luego consultará la BD para obtener mas ticket,
        creando con ellos nuevos ticket para ya tenerlos en la memoria.

        Keyword arguments:
        empleado -- <class 'lib.empleado'>
        ultimo_grupo -- <class 'lib.database.GrupoDeResolucionBD'>
        clasificacion -- <class 'lib.database.ClasificacionBD'>
        estado -- <class 'lib.database.Estado'>
        nro_ticket -- int
        fecha_apertura_desde -- <type 'datetime.datetime'>
        fecha_apertura_hasta -- <type 'datetime.datetime'>
        fecha_ultimo_cambio_desde -- <type 'datetime.datetime'>
        fecha_ultimo_cambio_hasta -- <type 'datetime.datetime'>

        Return:
        lista_ticket -- [<class 'lib.ticket'>]
        """
        # Algunos casos
        lista_ticket = []
        if (empleado and clasificacion == "Todas" and
                ultimo_grupo == "Todos" and 
                fecha_apertura_desde == fecha_apertura_hasta and
                fecha_ultimo_cambio_desde == fecha_ultimo_cambio_hasta):
            if nro_ticket:
                # Busco el ticket con ese numero y que sea del empleado
                if self.tickets.get(nro_ticket):
                    lista_ticket.append(self.tickets.get(nro_ticket))
                else:
                    ticket, flag = self.buscar_ticket_BD(nro_ticket, empleado)
                    if flag:
                        lista_ticket.append(ticket)
                        return lista_ticket
                    else:
                        return None
            else:
                # Busco todos los ticket que tenga el empleado
                return empleado.tickets_reclamados
        else:
            #No me puso empleado.
            # Chanchada de codigo
            tickets = Ticket.select()
            lista_ticket = list(tickets)
            # Clasificacion
            if clasificacion != "Todas":
                for ticket in lista_ticket:
                    if (ticket.historial_de_clasificacion[-1].clasificacion !=
                            clasificacion):
                        lista_ticket.remove(ticket)
            # Estado
            if estado != "Todos":
                #aca entra
                for ticket in lista_ticket:
                    if (ticket.historial_de_estado[-1].estado != estado):
                        lista_ticket.remove(ticket)
            #Ultimo grupo
            if ultimo_grupo != "Todos":
                for ticket in lista_ticket:
                    if(ticket.grupo_de_resolucion != ultimo_grupo):
                        lista_ticket.remove(ticket)
            # Faltan Fechas
            return lista_ticket

    def buscar_ticket_BD(self, nro_ticket, empleado):
        """Busca en la BD el ticket con el numero 'nro_ticket'.

        Si el empleado es igual a 'empleado' devuelve el ticket. Sino devuelve
        una lista vacia.

        Keyword arguments:
        nro_ticket -- int
        empleado -- type: <class 'lib.database.empleado'>
        """
        consulta = Ticket.selectBy(id = nro_ticket,
                empleado_id = empleado.id)
        try:
            # Tenemos el ticket y es del empleado. Creamos el ticket y
            # devolvemos True
            ticket = consulta[0]
            print "Resultado de la busqueda: "
            print ticket
            return ticket, True
            """
            nuevo_ticket = Ticket()
            nuevo_ticket.numero = ticket.id
            nuevo_ticket.empleado = empleado
            nuevo_ticket.usuario_creacion = Usuario(ticket.usuario_creacion)
            if ticket.usuario_cierre:
                nuevo_ticket.usuario_cierre = Usuario(ticket.usuario_cierre)
            else:
                nuevo_ticket.usuario_cierre = None
            nuevo_ticket.grupo_actual = GrupoDeResolucion(ticket.grupo_de_resolucion)
            nuevo_ticket.descripcion = ticket.descripcion
            #import pdb
            #pdb.set_trace()
            nuevo_ticket.fecha_creacion = ticket.fecha_creacion
            nuevo_ticket.fecha_cierre = ticket.fecha_cierre
            # !!!FIXME: estos for lo podemos hacer directamente llamando a las
            # funciones de la variable recien creada 'ticket'. Ver si lo hacemos
            # asi y hacer las pruebas correspondientes.
            # Historial de clasificaciones
            historial_de_clasificacion = []
            for hc in ticket.historial_de_clasificacion:
                clasificacion = hc
                historial_de_clasificacion.append(
                        HistorialDeClasificacion(
                            Clasificacion(clasificacion.clasificacion)))
            nuevo_ticket.historial_de_clasificacion = historial_de_clasificacion
            # Historial de estado
            historial_de_estado = []
            for estado in ticket.historial_de_estado[0].estados:
                historial_de_estado.append(
                        HistorialDeEstado(Estado(estado)))
            nuevo_ticket.historial_de_estado = historial_de_estado
            # Intervenciones
            intervenciones = []
            for intervencion in ticket.intervenciones:
                intervenciones.append(Intervencion(intervencion))
            nuevo_ticket.intervenciones = intervenciones
            return nuevo_ticket, True
            """
        except IndexError, error:
            return "", False

    def armar_ticket(self, ticket_bd):
        """Creará una nueva instancia de Ticket con los datos obtenidos de BD.

        Keyword arguments:
        ticket -- <class 'lib.database.Ticket'>

        """
        import pdb
        #pdb.set_trace()
        ticket = Ticket()
        print "Antes:"
        print ticket_bd.usuario_creacion
        usuario_creacion = Usuario(ticket_bd.usuario_creacion)
        print "Despues: "
        print ticket_bd.usuario_creacion
        usuario_cierre = Usuario(ticket_bd.usuario_cierre)
        grupo_actual = GrupoDeResolucion(ticket_bd.grupo_de_resolucion_)
        descripcion = ticket_bd.descrpcion
        fecha_creacion = ticket_bd.fecha_creacion
        fecha_cierre = ticket_bd.fecha_cierre
        #Asignamos valores
        # !!!FIXME: estos for lo podemos hacer directamente llamando a las
        # funciones de la variable recien creada 'ticket'. Ver si lo hacemos
        # asi y hacer las pruebas correspondientes.
        # Historial de clasificaciones
        historial_de_clasificacion = []
        for hc in ticket_bd.historial_de_clasificacion:
            clasificacion = hc[0]
            historial_de_clasificacion.append(
                    HistorialDeClasificacion(
                        Clasificacion(clasificacion.clasificacion)))
        ticket.historial_de_clasificacion = historial_de_clasificacion
        # Historial de estado
        historial_de_estado = []
        for he in ticket_bd.historial_de_estado:
            estado = he[0]
            historial_de_estado.append(
                    HistorialDeEstado(Estado(estado)))
        ticket.historial_de_estado = historial_de_estado
        # Intervenciones
        intervenciones = []
        for intervencion in ticket_bd.intervenciones:
            intervenciones.append(Intervencion(intervencion))
        ticket.intervenciones = intervenciones
        return ticket

